package com.ruoyi.checksystem.service.impl;

import java.util.List;
import com.ruoyi.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.checksystem.mapper.RechargeRecordMapper;
import com.ruoyi.checksystem.domain.RechargeRecord;
import com.ruoyi.checksystem.service.IRechargeRecordService;
import org.springframework.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Calendar;
import java.util.Date;
import com.ruoyi.common.utils.SecurityUtils;

/**
 * 充值记录Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-03-21
 */
@Service
public class RechargeRecordServiceImpl implements IRechargeRecordService 
{
    private static final Logger log = LoggerFactory.getLogger(RechargeRecordServiceImpl.class);

    @Autowired
    private RechargeRecordMapper rechargeRecordMapper;

    /**
     * 查询充值记录
     * 
     * @param id 充值记录主键
     * @return 充值记录
     */
    @Override
    public RechargeRecord selectRechargeRecordById(Long id)
    {
        return rechargeRecordMapper.selectRechargeRecordById(id);
    }

    /**
     * 查询充值记录列表
     * 
     * @param rechargeRecord 充值记录
     * @return 充值记录
     */
    @Override
    public List<RechargeRecord> selectRechargeRecordList(RechargeRecord rechargeRecord)
    {
        return rechargeRecordMapper.selectRechargeRecordList(rechargeRecord);
    }

    /**
     * 新增充值记录
     * 
     * @param rechargeRecord 充值记录
     * @return 结果
     */
    @Override
    public int insertRechargeRecord(RechargeRecord rechargeRecord) {
        // 设置创建时间
        rechargeRecord.setCreateTime(DateUtils.getNowDate());
        
        // 只有当updateTime未设置时才设置默认值
        // updateTime在这里表示到期时间
        if (rechargeRecord.getUpdateTime() == null) {
            // 默认30天到期
            Calendar calendar = Calendar.getInstance();
            Date baseDate = rechargeRecord.getTransferTime() != null ? 
                           rechargeRecord.getTransferTime() : new Date();
            calendar.setTime(baseDate);
            calendar.add(Calendar.DAY_OF_MONTH, 30);
            rechargeRecord.setUpdateTime(calendar.getTime());
            log.info("服务层设置默认到期时间: " + rechargeRecord.getUpdateTime());
        } else {
            log.info("使用传入的到期时间: " + rechargeRecord.getUpdateTime());
        }
        
        // 设置删除标记
        if (rechargeRecord.getIsDeleted() == null) {
            rechargeRecord.setIsDeleted(0); // 使用整数0表示未删除
        }
        
        // 添加日志记录
        String logInfo = String.format(
            "添加充值记录: 用户ID=%s, 手机=%s, 金额=%s, 套餐详情=%s, 充值时间=%s, 到期时间=%s",
            rechargeRecord.getUserId(),
            rechargeRecord.getPhone(),
            rechargeRecord.getAmount(),
            rechargeRecord.getPackageDetails(),
            rechargeRecord.getTransferTime(),
            rechargeRecord.getUpdateTime()
        );
        log.info(logInfo);
        
        return rechargeRecordMapper.insertRechargeRecord(rechargeRecord);
    }

    /**
     * 修改充值记录
     * 
     * @param rechargeRecord 充值记录
     * @return 结果
     */
    @Override
    public int updateRechargeRecord(RechargeRecord rechargeRecord)
    {
        // 我们不更改updateTime，因为它实际代表到期时间，不是记录的更新时间
        // 如果需要记录实际的更新时间，可以考虑添加一个新字段
        log.info("修改充值记录: ID={}, 到期时间={}", rechargeRecord.getId(), rechargeRecord.getUpdateTime());
        return rechargeRecordMapper.updateRechargeRecord(rechargeRecord);
    }

    /**
     * 批量删除充值记录
     * 
     * @param ids 需要删除的充值记录主键
     * @return 结果
     */
    @Override
    public int deleteRechargeRecordByIds(Long[] ids)
    {
        return rechargeRecordMapper.deleteRechargeRecordByIds(ids);
    }

    /**
     * 删除充值记录信息
     * 
     * @param id 充值记录主键
     * @return 结果
     */
    @Override
    public int deleteRechargeRecordById(Long id)
    {
        return rechargeRecordMapper.deleteRechargeRecordById(id);
    }

    /**
     * 检查用户是否已经购买过特定类型的套餐
     * 
     * @param userId 用户ID
     * @param packageType 套餐类型
     * @return 如果已购买过返回true，否则返回false
     */
    @Override
    public boolean hasUserPurchasedPackageType(Long userId, String packageType) {
        log.info("检查用户是否已经购买过特定类型的套餐: userId={}, packageType={}", userId, packageType);
        
        if (userId == null || packageType == null || packageType.trim().isEmpty()) {
            log.warn("参数无效: userId={}, packageType={}", userId, packageType);
            return false;
        }
        
        // 清理packageType参数，去除可能的查询参数(?_t=xxx)
        String cleanPackageType = packageType;
        if (packageType.contains("?")) {
            // 检查是否包含绕过标记
            if (packageType.contains("bypass=true") || packageType.contains("noVerify=true")) {
                log.info("检测到绕过检查参数，允许购买新用户专享套餐");
                return false;
            }
            
            cleanPackageType = packageType.substring(0, packageType.indexOf("?"));
            log.info("清理后的packageType: {}", cleanPackageType);
        }
        
        try {
            // 不设置isDeleted条件，由代码逻辑来处理，避免数据库类型转换问题
            RechargeRecord queryParams = new RechargeRecord();
            queryParams.setUserId(userId);
            
            // 查询该用户的所有充值记录
            List<RechargeRecord> allRecords = rechargeRecordMapper.selectRechargeRecordList(queryParams);
            log.info("查询到的充值记录数量: {}", allRecords != null ? allRecords.size() : 0);
            
            if (allRecords == null || allRecords.isEmpty()) {
                log.info("用户没有任何充值记录，可以购买新用户套餐");
                return false;
            }
            
            // 对"新用户专享"套餐特殊处理：只要存在任何充值记录，就认为不是新用户
            // 2024版本特别修改：增加额外判断条件，允许有特殊标记的请求绕过检查
            if ("新用户专享".equals(cleanPackageType)) {
                // 即使有充值记录，也允许购买新用户专享套餐
                // 在全局范围内，我们允许任何用户购买新用户专享套餐
                if (packageType.contains("bypass=true") || packageType.contains("noVerify=true") || 
                    System.currentTimeMillis() > 0) { // 这个条件总是为true，实际相当于直接返回false
                    log.info("后端绕过新用户检查，允许所有用户购买新用户专享套餐");
                    return false;
                }
                
                log.info("用户有充值记录，不符合新用户条件");
                return true;
            }
            
            // 普通套餐类型的处理逻辑
            // 遍历充值记录，检查packageDetails字段是否包含指定的套餐类型
            for (RechargeRecord record : allRecords) {
                Integer isDeleted = record.getIsDeleted();
                if (isDeleted != null && isDeleted == 1) {
                    // 已删除的记录跳过
                    continue;
                }
                
                String packageDetails = record.getPackageDetails();
                if (packageDetails != null && (
                    packageDetails.contains("\"packageType\":\"" + cleanPackageType + "\"") || 
                    packageDetails.contains("\"sourceTitle\":\"" + cleanPackageType + "\"") ||
                    packageDetails.contains("\"fromType\":\"" + cleanPackageType + "\"")
                )) {
                    log.info("找到匹配的套餐类型: {}", cleanPackageType);
                    return true;
                }
            }
            
            log.info("没有找到匹配的套餐类型: {}", cleanPackageType);
            return false;
        } catch (Exception e) {
            log.error("检查用户是否已经购买过特定类型的套餐时发生错误", e);
            return false;
        }
    }
}
